package com.huiying.service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huiying.entity.entity.Conversation;
import com.huiying.entity.entity.Message;
import com.huiying.entity.entity.User;
import com.huiying.mapper.ConversationMapper;
import com.huiying.mapper.MessageMapper;
import com.huiying.mapper.UserMapper;
import com.huiying.service.ConversationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 会话服务实现类
 */
@Service
@Slf4j
public class ConversationServiceImpl extends ServiceImpl<ConversationMapper, Conversation> implements ConversationService {

    /**
     * 根据两个用户ID查找或创建会话。
     * 约定：user1Id 总是两个用户ID中较小的，user2Id 总是较大的。
     *
     * @param user1Id 会话参与者1的ID
     * @param user2Id 会话参与者2的ID
     * @return 找到或创建的会话对象
     */

    @Autowired
    private ConversationMapper conversationMapper;

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private MessageMapper messageMapper;

    @Override
    @Transactional // 确保这是一个事务性操作，尤其是涉及创建新记录
    public Conversation findOrCreateConversation(Long user1Id, Long user2Id) {
        // 确保 user1Id 总是较小的值，user2Id 总是较大的值，以符合数据库唯一约束 uk_user_pair
        Long minId = Math.min(user1Id, user2Id);
        Long maxId = Math.max(user1Id, user2Id);

        // 1. 尝试查找现有会话
        QueryWrapper<Conversation> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user1_id", minId).eq("user2_id", maxId);
        Conversation conversation = conversationMapper.selectOne(queryWrapper);

        if (conversation == null) {
            // 2. 如果会话不存在，则创建新会话
            log.info("会话不存在，为用户 {} 和 {} 创建新会话。", minId, maxId);
            conversation = Conversation.builder()
                    .user1Id(minId)
                    .user2Id(maxId)
                    .createdTime(LocalDateTime.now())
                    .updatedTime(LocalDateTime.now())
                    // lastMessageAt 初始可以为 null，当第一条消息保存后更新
                    .build();
            // 调用IService的save方法保存
            this.save(conversation); // 等同于 baseMapper.insertUser(conversation);
            log.info("新会话创建成功，ID: {}", conversation.getId());
        } else {
            log.info("找到现有会话，ID: {}", conversation.getId());
        }
        return conversation;
    }

    /**
     * 更新指定会话的最后消息时间。
     *
     * @param conversationId 会话ID
     * @param lastMessageTime 最后一条消息的时间
     */
    @Override
    @Transactional
    public void updateLastMessageAt(Long conversationId, LocalDateTime lastMessageTime) {
        Conversation conversation = this.getById(conversationId); // 使用IService的getById方法
        if (conversation != null) {
            conversation.setLastMessageAt(lastMessageTime);
            conversation.setUpdatedTime(LocalDateTime.now());
            this.updateById(conversation); // 使用IService的updateById方法
            log.debug("会话ID {} 的最后消息时间已更新为 {}", conversationId, lastMessageTime);
        } else {
            log.warn("尝试更新不存在的会话ID {} 的最后消息时间。", conversationId);
        }
    }

    /**
     * 获取指定用户参与的所有会话列表，按最后消息时间倒序排列。
     *
     * @param userId 用户ID
     * @return 会话列表
     */
    @Override
    public List<Conversation> getConversationsByUserId(Long userId) {
        QueryWrapper<Conversation> queryWrapper = new QueryWrapper<>();
        // 查询 user1_id 或 user2_id 中包含该用户ID的会话
        queryWrapper.nested(i -> i.eq("user1_id", userId).or().eq("user2_id", userId))
                    .orderByDesc("last_message_at"); // 按最后消息时间倒序

        List<Conversation> conversations = conversationMapper.selectList(queryWrapper);

        // 2. 遍历列表，为每个会话对象填充附加信息
        for (Conversation conversation : conversations) {
            // a. 确定聊天伙伴的ID
            Long partnerId = conversation.getUser1Id().equals(userId) ? conversation.getUser2Id() : conversation.getUser1Id();
            conversation.setPartnerId(partnerId);

            // b. 根据伙伴ID查询用户基本信息（昵称和头像）
            User partner = userMapper.selectById(partnerId);
            if (partner != null) {
                conversation.setPartnerName(partner.getUsername());
                conversation.setPartnerAvatar(partner.getAvatar());
            }

            // c. 查询该会话的最后一条消息内容
            // (假设你有一个根据会话ID查询最后一条消息的方法)
            Message lastMessage = messageMapper.findLastMessageByConversationId(conversation.getId());
            if (lastMessage != null) {
                conversation.setLastMessage(lastMessage.getContent());
            }
        }

        log.info("查询到用户 {} 的 {} 条会话记录。", userId, conversations.size());
        return conversations;
    }

    /**
     * 检查指定用户是否是某个会话的参与者。
     *
     * @param userId 用户ID
     * @param conversationId 会话ID
     * @return 如果用户是会话参与者则返回 true，否则返回 false
     */
    @Override
    public boolean isUserInConversation(Long userId, Long conversationId) {
        QueryWrapper<Conversation> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", conversationId)
                    .and(i -> i.eq("user1_id", userId).or().eq("user2_id", userId));

        Long count = conversationMapper.selectCount(queryWrapper); // 使用 selectCount 更高效
        boolean isInConversation = count > 0;
        log.debug("用户 {} 是否在会话 {} 中: {}", userId, conversationId, isInConversation);
        return isInConversation;
    }
}